Python HTTP klientide lahkamine: Requests, httpx ja urllib3 põhjalik analüüs

Kaasaegse tarkvaraarenduse maailmas on suhtlus võtmetähtsusega. Rakendused ei eksisteeri harva isolatsioonis; nad suhtlevad andmebaaside, kolmanda osapoole teenuste ja teiste mikroteenustega, peamiselt API-de kaudu Hypertext Transfer Protocol (HTTP) abil. Pythoni arendajate jaoks on nende HTTP-päringute tegemine põhiülesanne ning selle töö jaoks valitud raamatukogu võib oluliselt mõjutada teie tootlikkust, rakenduse jõudlust ja koodi hooldatavust.

Pythoni ökosüsteem pakub selleks rikkalikku valikut tööriistu, kuid kolm nime paistavad pidevalt silma: urllib3, robustne alus; Requests, universaalselt armastatud standard; ja httpx, kaasaegne, asünkroonseid võimalusi pakkuv võistleja. Nende vahel valimine ei seisne ainuüksi "parima" raamatukogu leidmises, vaid pigem nende unikaalsete tugevuste mõistmises ja õige tööriista valimises teie konkreetsete vajaduste jaoks. See juhend pakub põhjalikku, professionaalset võrdlust, et aidata teil teha teadlik otsus.

Aluse mõistmine: Mis on HTTP klient?

Oma olemuselt on HTTP klient tarkvaraosa, mis on loodud HTTP-päringute saatmiseks serverile ja vastuvõetud HTTP-vastuste töötlemiseks. See lihtne definitsioon peidab endas suurt hulka keerukust. Tugev HTTP kliendi raamatukogu haldab arvukaid madala taseme üksikasju, sealhulgas:

• Võrgu pistikupesade ja ühenduste haldamine.
• HTTP-päringute korrektne vormindamine päistede, kehade ja meetoditega (GET, POST, PUT jne).
• Ümbersuunamiste ja ajapiirangute käsitlemine.
• Küpsiste ja sessioonide haldamine olekuga suhtluse jaoks.
• Erinevate sisu kodeeringutega (nagu JSON või vormiandmed) tegelemine.
• SSL/TLS-i käsitlemine turvaliste HTTPS-ühenduste jaoks.
• Parema jõudluse tagamiseks ühenduste taaskasutamine (ühenduste kogumamine).

Kuigi Pythoni standardteek sisaldab mooduleid nagu urllib.request, peetakse neid igapäevaseks kasutamiseks sageli liiga madala tasemega ja tülikateks. See on viinud võimsamate, kasutajasõbralike, kolmanda osapoole raamatukogude arendamiseni, mis abstraheerivad selle keerukuse, võimaldades arendajatel keskenduda oma rakenduse loogikale.

Klassikaline meister: urllib3

Enne kui arutame kõrgema taseme raamatukogusid, on oluline mõista urllib3. See on üks enim allalaaditud pakette PyPI-s, mitte sellepärast, et enamik arendajaid seda otse kasutab, vaid sellepärast, et see on võimas, usaldusväärne mootor, mis toidab lugematuid teisi kõrgema taseme raamatukogusid, eriti aga Requests.

Mis on urllib3?

urllib3 on Pythoni jaoks võimas, tervet mõistust järgiv HTTP klient. Selle peamine fookus on usaldusväärse ja tõhusa HTTP-side aluse pakkumisel. See ei ole loodud samasuguse rõhuga API elegantsile nagu Requests, vaid pigem õigsusele, jõudlusele ja täpsele kontrollile.

Põhiomadused ja tugevused

• Ühenduste kogumamine: See on vaieldamatult selle kõige kriitilisem funktsioon. urllib3 haldab ühenduste kogusid. Kui teete päringu hostile, millega olete varem ühendust võtnud, kasutab see uue loomise asemel olemasolevat ühendust uuesti. See vähendab drastiliselt järjestikuste päringute latentsust, kuna TCP- ja TLS-kätluste üleliigne töö välditakse.
• Lõimete turvalisus: Ühte PoolManager eksemplari saab jagada mitme lõime vahel, muutes selle robustseks valikuks mitmelõimeliste rakenduste jaoks.
• Tugev veahaldus ja kordusülesanded: See pakub keerukaid mehhanisme ebaõnnestunud päringute kordamiseks, koos seadistatavate tagasilöögistrateegiatega, mis on oluline vastupidavate rakenduste loomiseks, mis suhtlevad potentsiaalselt ebastabiilsete teenustega.
• Täpne kontroll: See paljastab hulgaliselt konfiguratsioonivalikuid, võimaldades arendajatel ajapiiranguid, TLS-i kontrollimist, puhverserveri sätteid ja palju muud täpselt seadistada.
• Failide üleslaadimine: Sellel on suurepärane tugi multipart vormiandmete kodeerimiseks, muutes failide tõhusaks üleslaadimise lihtsaks.

Näidiskood: GET-päringu tegemine

urllib3 kasutamine on selle kõrgema taseme vastete kõrval töömahukam, kuid siiski lihtne. Tavaliselt suhtlete PoolManager eksemplariga.

            
import urllib3
import json

# Soovitatav on luua üks PoolManager eksemplar ja seda taaskasutada
http = urllib3.PoolManager()

# Siht URL-i määramine
url = "https://api.github.com/users/python"

# Päringu tegemine
# Märkus: päringu meetod edastatakse stringina ('GET')
# Vastuse objekt on HTTPResponse eksemplar
response = http.request("GET", url, headers={"User-Agent": "My-Urllib3-App/1.0"})

# Vastuse staatuse kontrollimine
if response.status == 200:
    # Andmed tagastatakse baitidena ja vajavad dekodeerimist
    data_bytes = response.data
    data_str = data_bytes.decode("utf-8")
    
    # JSONi käsitsi parkimine
    user_data = json.loads(data_str)
    
    print(f"Kasutajanimi: {user_data['name']}")
    print(f"Avalikud repositooriumid: {user_data['public_repos']}")
else:
    print(f"Viga: Saadud staatuse kood {response.status}")

# Ühendus vabastatakse automaatselt tagasi kogusse

            

              
                Copy
              
            
          

Millal kasutada urllib3

• Kui te ehitate raamatukogu või raamistikku, mis peab tegema HTTP-päringuid ja soovite sõltuvusi täpselt hallata.
• Kui vajate ülimat jõudlust ja kontrolli ühenduste haldamise ja kordusülesannete loogika üle.
• Pärandisüsteemides või piiratud keskkondades, kus peate toetuma raamatukogule, mida teised suured paketid sageli sisaldavad (vendored).

Kohtuotsus urllib3 kohta

Plussid: Väga jõudlus, lõimete turvalisus, vastupidavus ja pakub sügavat kontrolli päringu elutsükli üle.
Miinused: API on töömahukas ja vähem intuitiivne. See nõuab tavaliste toimingute nagu JSON dekodeerimine ja päringuparameetrite kodeerimine käsitsi tegemist.

Rahva valik: requests - "HTTP inimestele"

Üle kümne aasta on requests olnud Pythonis HTTP-päringute tegemise de facto standard. Selle kuulus loosung "HTTP inimestele" haarab täiuslikult selle disainifilosoofia. See pakub kaunist, lihtsat ja elegantset API-t, mis peidab endas urllib3 hallatavat keerukust.

Mis on requests?

requests on kõrgema taseme HTTP-raamatukogu, mis keskendub arendajakogemusele ja kasutuslihtsusele. See pakub urllib3 võimsust intuitiivses liideses, muutes tavalised toimingud uskumatult lihtsaks, samas pakkudes vajadusel juurdepääsu võimsatele funktsioonidele.

Põhiomadused ja tugevused

• Lihtne, elegantne API: API-ga on rõõm töötada. GET-päringu tegemine on üksainus, loetav koodirida.
• Sessiooni objektid: Sessiooni objektid on põhifunktsioon. Need säilitavad parameetreid päringute vahel, haldavad küpsiseid automaatselt ja, mis kõige tähtsam, kasutavad taustal urllib3 ühenduste kogumist. Session kasutamine on soovitatav viis requests-iga kõrge jõudluse saavutamiseks.
• Sisseehitatud JSON dekodeerimine: JSON API-dega suhtlemine on triviaalne. Vastuse objektil on .json() meetod, mis dekodeerib vastuse keha automaatselt ja tagastab Pythoni sõnastiku või loendi.
• Automaatne sisu dekompresseerimine: See käsitleb läbipaistvalt tihendatud vastuseandmeid (gzip, deflate), nii et te ei pea sellele mõtlema.
• Keerukate andmete graatsiline käsitlemine: Vormiandmete või JSON-i koormuste saatmine on sama lihtne kui sõnastiku edastamine data või json parameetrile.
• Rahvusvahelised domeenid ja URL-id: Suurepärane, kohe valmis tugi globaalsele veebile.

Näidiskood: GET-päringu tegemine ja JSON-i käsitlemine

Võrrelge selle näite lihtsust urllib3 versiooniga. Pange tähele käsitsi dekodeerimise või JSON-i parkimise puudumist.

            
import requests

# Soovitatav lähenemine mitmele päringule sama hosti kohta
with requests.Session() as session:
    session.headers.update({"User-Agent": "My-Requests-App/1.0"})

    url = "https://api.github.com/users/python"

    try:
        # Päringu tegemine on üks funktsiooni kutse
        response = session.get(url)
        
        # Erandi tekitamine halva staatuse koodi korral (4xx või 5xx)
        response.raise_for_status()
        
        # .json() meetod tegeleb dekodeerimise ja parkimisega
        user_data = response.json()
        
        print(f"Kasutajanimi: {user_data['name']}")
        print(f"Avalikud repositooriumid: {user_data['public_repos']}")

    except requests.exceptions.RequestException as e:
        print(f"Tekkis viga: {e}")


            

              
                Copy
              
            
          

Millal kasutada requests

• Enamiku sünkroonsete HTTP-ülesannete jaoks rakendustes, skriptides ja andmeteaduse projektides.
• REST API-dega suheldes.
• Kiireks prototüüpide loomiseks ja sisemiste tööriistade ehitamiseks.
• Kui teie peamine eesmärk on koodi loetavus ja arenduskiirus sünkroonsete võrgu I/O jaoks.

Arvestatavad piirangud

requestsi peamine piirang tänapäeval on see, et selle API on rangelt sünkroonne. See blokeerib, kuni vastus on saadud. See muudab selle sobimatuks kõrge samaegsust nõudvate rakenduste jaoks, mis on ehitatud asünkroonsete raamistike nagu asyncio, FastAPI või Starlette abil. Kuigi te saate seda kasutada lõimete kogumis, on see lähenemine vähem tõhus kui natiivne asünkroon-I/O, et hallata tuhandeid samaaegseid ühendusi.

Kohtuotsus requests kohta

Plussid: Uskumatult lihtne kasutada, väga loetav, rikkalik funktsioonide komplekt, tohutu kogukond ja suurepärane dokumentatsioon.
Miinused: Ainult sünkroonne. See on kaasaegsete, kõrge jõudlusega, I/O-sid nõudvate rakenduste jaoks märkimisväärne puudus.

Moodne võistleja: httpx - Asünkroonselt valmis järglane

httpx on kaasaegne, täielikult funktsionaalne HTTP klient, mis ilmus, et kõrvaldada requestsi piirangud, peamiselt selle asünkroonse toe puudumine. See on loodud järgmise põlvkonna kliendiks, võttes kasutusele kaasaegsed Pythoni funktsioonid ja veebiprotokollid, pakkudes samal ajal tuttavat API-t neile, kes tulevad requestsist.

Mis on httpx?

httpx on Pythoni mitmekülgne HTTP klient, mis pakub nii sünkroonset kui ka asünkroonset API-t. Selle tapjafunktsioon on esmaklassiline tugi async/await süntaksile. Lisaks toob see kaasa toe kaasaegsetele veebiprotokollidele nagu HTTP/2 ja HTTP/3, mis võivad pakkuda märkimisväärseid jõudluse parandusi.

Põhiomadused ja tugevused

• Sünkroon- ja asünkroonitugi: See on selle määrav omadus. Saate kasutada sama raamatukogu ja väga sarnast API-t nii traditsiooniliste sünkroonsete skriptide kui ka kõrge jõudlusega asünkroonsete rakenduste jaoks. See ühtlustamine lihtsustab sõltuvuste haldamist ja vähendab õppimiskõverat.
• HTTP/2 ja HTTP/3 tugi: Erinevalt requestsist suudab httpx rääkida HTTP/2 keelt. See protokoll võimaldab multipleksimist – mitmete päringute ja vastuste saatmist ühe ühenduse kaudu samaaegselt – mis võib dramaatiliselt kiirendada suhtlust kaasaegsete serveritega, kes seda toetavad.
• requestsiga ühilduv API: API oli tahtlikult loodud olema paljudel juhtudel requestsi "drop-in" asendaja. Funktsioonid nagu httpx.get() ja objektid nagu httpx.Client() (requests.Session() ekvivalent) tunduvad kohe tuttavad.
• Laiendatav transpordi API: Sellel on puhas, hästi määratletud transpordi API, mis muudab kohandatud adapterite kirjutamise lihtsamaks näiteks mokeerimise, vahemälu või kohandatud võrguprotokolli jaoks.

Näidiskoodid: Sünkroon, Asünkroon ja Kliendid

Esiteks sünkroonne näide. Pange tähele, kui sarnane see on requestsi koodiga.

            
# Sünkroonne httpx kood
import httpx

url = "https://api.github.com/users/python-httpx"

with httpx.Client(headers={"User-Agent": "My-HTTPX-App/1.0"}) as client:
    try:
        response = client.get(url)
        response.raise_for_status()
        user_data = response.json()
        
        print(f"(Sünkroon) Kasutajanimi: {user_data['name']}")
        print(f"(Sünkroon) Avalikud repositooriumid: {user_data['public_repos']}")

    except httpx.RequestError as e:
        print(f"Tekkis viga: {e}")

            

              
                Copy
              
            
          

Nüüd asünkroonne versioon. Struktuur on sama, kuid see kasutab async/await mitteblokeeriva I/O sooritamiseks.

            
# Asünkroonne httpx kood
import httpx
import asyncio

async def fetch_github_user():
    url = "https://api.github.com/users/python-httpx"
    
    # Asünkroonsete toimingute jaoks kasutage AsyncClienti
    async with httpx.AsyncClient(headers={"User-Agent": "My-HTTPX-App/1.0"}) as client:
        try:
            # 'await' võtmesõna peatab täitmise, kuni võrgukutse lõpeb
            response = await client.get(url)
            response.raise_for_status()
            user_data = response.json()
            
            print(f"(Asünkroon) Kasutajanimi: {user_data['name']}")
            print(f"(Asünkroon) Avalikud repositooriumid: {user_data['public_repos']}")

        except httpx.RequestError as e:
            print(f"Tekkis viga: {e}")

# Käivitage asünkroonfunktsioon
asyncio.run(fetch_github_user())

            

              
                Copy
              
            
          

Millal kasutada httpx

• Iga uue projekti jaoks, mis alustab täna. Selle sünkroonne/asünkroonne duaalsus muudab selle tulevikukindlaks valikuks. Isegi kui te vajate täna ainult sünkroonseid päringuid, olete httpx-i kasutades valmis sujuvaks üleminekuks asünkroonsele, kui teie rakenduse vajadused arenevad. See on selge valik mis tahes projekti jaoks, mis hõlmab kaasaegseid veebiraamistikke või nõuab kõrget samaegsust.
• Rakenduste loomisel asünkroonsete raamistike nagu FastAPI, Starlette, Sanic või Django 3+ abil.
• Kui peate tegema suure hulga samaaegseid I/O-sid nõudvaid päringuid (nt tuhandete API-de kutsumine).
• Kui peate suhtlema serveritega, mis kasutavad jõudluse tagamiseks HTTP/2.

Kohtuotsus httpx kohta

Plussid: Pakub nii sünkroonseid kui ka asünkroonseid API-sid, toetab HTTP/2, on kaasaegse ja puhta disainiga ning pakub requests kasutajatele tuttavat API-t.
Miinused: Noorema projektina pole selle kolmanda osapoole pistikprogrammide ökosüsteem nii lai kui requestsil, kuigi see kasvab kiiresti.

Funktsioonide võrdlus: Lühidalt

See kokkuvõte pakub kiiret viidet kolme raamatukogu peamiste erinevuste kohta.

Funktsioon: Kõrgema taseme, kasutajasõbralik API

• urllib3: Ei. Madala taseme ja töömahukas.
• requests: Jah. See on selle peamine tugevus.
• httpx: Jah. Loodud olema tuttav `requests` kasutajatele.

Funktsioon: Sünkroonne API

• urllib3: Jah.
• requests: Jah.
• httpx: Jah.

Funktsioon: Asünkroonne API (async/await)

• urllib3: Ei.
• requests: Ei.
• httpx: Jah. See on selle peamine erinevus.

Funktsioon: HTTP/2 tugi

• urllib3: Ei.
• requests: Ei.
• httpx: Jah.

Funktsioon: Ühenduste kogumamine

• urllib3: Jah. Põhiomadus.
• requests: Jah (Session objektide kaudu).
• httpx: Jah (Client ja AsyncClient objektide kaudu).

Funktsioon: Sisseehitatud JSON dekodeerimine

• urllib3: Ei. Vajab käsitsi dekodeerimist ja parkimist.
• requests: Jah (response.json() kaudu).
• httpx: Jah (response.json() kaudu).

Jõudluse kaalutlused

Kui arutame jõudlust, on kontekst kõik. Ühe lihtsa päringu puhul on nende kolme raamatukogu jõudluse erinevus tühine ja tõenäoliselt kaob võrgu latentsusesse.

Seal, kus jõudluse erinevused tõeliselt ilmnevad, on samaegsuse käsitlemine:

• `requests` mitmelõimelises keskkonnas: See on traditsiooniline viis samaegsuse saavutamiseks `requests`-iga. See töötab, kuid lõimedel on kõrgem mälukasutus ja need võivad kannatada kontekstivahetuse kulude all, eriti kui samaaegsete ülesannete arv kasvab sadadesse või tuhandetesse.
• `httpx` koos `asyncio`-ga: I/O-sid nõudvate ülesannete, nagu API-kõnede tegemine, jaoks on `asyncio` palju tõhusam. See kasutab tuhandete samaaegsete ühenduste haldamiseks minimaalse üleliigse tööga ühte lõime ja sündmuste silmust. Kui teie rakendus peab samaaegselt uurima sadu mikroteenuseid, on `httpx` lõimitud `requests`i rakendusega võrreldes tohutult parem.

Lisaks võib `httpx`i HTTP/2 tugi pakkuda täiendavat jõudlust, kui suheldakse serveriga, mis seda samuti toetab, kuna see võimaldab mitmeid päringuid saata sama TCP ühenduse kaudu ilma vastuseid ootamata, vähendades latentsust.

Valige oma projekti jaoks sobiv raamatukogu

Põhineudes sellel põhjalikul analüüsil, siin on meie tegevusettepanekud arendajatele üle maailma:

Kasutage `httpx`i, kui...

Te alustate mingisugust uut Pythoni projekti 2023. aastal või hiljem. Selle duaalne sünkroon-/asünkrooniline olemus muudab selle kõige mitmekülgsemaks ja tulevikukindlamaks valikuks. Isegi kui vajate täna ainult sünkroonseid päringuid, olete `httpx`i kasutades valmis sujuvaks üleminekuks asünkroonsele, kui teie rakenduse vajadused arenevad. See on selge valik mis tahes projekti jaoks, mis hõlmab kaasaegseid veebiraamistikke või nõuab kõrget samaegsust.

Kasutage `requests`i, kui...

Te töötate pärandkoodibaasis, mis juba kasutab `requests`i ulatuslikult. Migratsiooni kulu ei pruugi olla kasu väärt, kui rakendus on stabiilne ega nõua samaegsust. See jääb täiesti korralikuks valikuks ka lihtsate, ühekordsete skriptide jaoks, kus asünkroonse sündmuste silmuse seadistamise üleliigne töö on tarbetu ja loetavus on esmatähtis.

Kasutage `urllib3`i, kui...

Te olete raamatukogu autor ja peate tegema HTTP-päringuid minimaalsete sõltuvuste ja maksimaalse kontrolliga. `urllib3`ist sõltudes väldite oma kasutajatele nii `requests`i kui ka `httpx`i pealesurumist. Samuti peaksite selle poole pöörduma, kui teil on väga spetsiifilised, madala taseme nõuded ühenduse või TLS-i haldamiseks, mida kõrgema taseme raamatukogud ei paku.

Kokkuvõte

Pythoni HTTP kliendi maastik pakub selget arenguteed. `urllib3` pakub võimsat, kivikindlat mootorit, mis toetab ökosüsteemi. `requests` ehitas selle mootori peale, et luua API, mis oli nii intuitiivne ja armastatud, et sellest sai ülemaailmne standard, demokratiseerides veebi juurdepääsu Pythoni programmeerijate põlvkonnale. Nüüd `httpx` seisab kaasaegse järglasena, säilitades `requests`i geniaalse kasutatavuse, integreerides samal ajal järgmise põlvkonna tarkvara jaoks vajalikud kriitilised funktsioonid: asünkroonsed toimingud ja kaasaegsed võrguprotokollid.

Tänaste arendajate jaoks on valik selgem kui kunagi varem. Kuigi `requests` jääb sünkroonsete ülesannete jaoks usaldusväärseks tööriistaks, on `httpx` edasivaatav valik peaaegu kõigi uute arenduste jaoks. Iga raamatukogu tugevusi mõistes saate enesekindlalt valida õige tööriista, tagades, et teie rakendused on vastupidavad, jõudluselt head ja tulevikuks valmis.